#include "head.h" //用户功能实现

// 数据操作
void user_data_file_print(u_list *list, const char *file_name) //  向文件写入航班信息
{
    FILE *fp = fopen(file_name, "w");
    if (NULL == fp)
    {
        ERRLOG("文件创建失败");
        return;
    }
    // 光标移动到开头
    fseek(fp, 0, SEEK_SET);

    // 遍历写入
    u_node *ptr = list->next;
    do
    {
        fprintf(fp, "用户名:%s\t密码:%s\t身份码:%d\t余额:%d\n",
                ptr->data.name, ptr->data.passwd, ptr->data.grade, ptr->data.value);
        ptr = ptr->next;
    } while (ptr != list->next);
    fflush(fp);

    fclose(fp);
    return;
}

void user_data_file_scanf(u_list *list, const char *file_name) //  向文件读取航班信息
{
    FILE *fp = fopen(file_name, "r");
    if (NULL == fp)
    {
        ERRLOG("文件创建失败");
        return;
    }

    clear_double_link_list_u(list);

    // 光标移动到开头
    fseek(fp, 0, SEEK_SET);

    // 判断文件行数
    u_data data;   // 存放数据
    char ch = '0'; // 接收文件的字符
    int len = 0;   // 判断文件的行数
    while (EOF != (ch = fgetc(fp)))
    {
        if ('\n' == ch)
        {
            len++;
        }
    }

    // 移动光标到头
    fseek(fp, 0, SEEK_SET);
    for (size_t i = 0; i < len; i++)
    {
        fscanf(fp, "用户名:%s\t密码:%s\t身份码:%d\t余额:%d\n",
               data.name, data.passwd, &data.grade, &data.value);
        // printf("用户名:%s\t密码:%s\t身份码:%d\t余额:%d\n",
        //        data.name, data.passwd, data.grade, data.value);
        insert_double_node_u(list, data, i + 1);
    }
    // fflush(fp);
    fclose(fp);
    return;
}

// 头节点到尾节点的节点个数
int get_circulate_node_count_u(u_list *list)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return 0;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 无数据");
        return 0;
    }
    if (list->next->next == list->next)
    {
        // ERRLOG("双向循环链表 只有一个数据");
        return 1;
    }

    int count = 1;
    u_node *ptr = list->next->next;
    while (ptr != list->next)
    {
        count++;
        ptr = ptr->next;
    }
    return count;
}

// 双向链表的创建
u_list *init_double_link_list_u()
{
    // 1、创建动态空间
    u_list *list = (u_list *)malloc(sizeof(u_list));
    if (NULL == list)
    {
        ERRLOG("创建动态空间失败");
        return NULL;
    }
    // 2、初始化赋值
    list->next = NULL;
    // 3、返回list
    return list;
}

// 双向链表的插入
void insert_double_node_u(u_list *list, u_data data, int pos)
{
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return;
    }

    // 创建数据结点
    u_node *new_node = (u_node *)malloc(sizeof(u_node));
    if (NULL == new_node)
    {
        ERRLOG("创建动态空间失败");
        return;
    }
    // 结点初始化
    new_node->data = data;
    new_node->next = new_node;
    new_node->prev = new_node;

    // int j =(get_circulate_node_count_u(list)+1);
    //     if (pos>j||pos<0);
    //     {
    //         ERRLOG("插入位置超出范围");
    //         return;
    //     }

    // 头插
    if (1 == pos || NULL == list->next)
    {
        // 内部有数据的头插
        if (1 == pos && NULL != list->next)
        {
            // 1 指向 第一个结点
            u_node *ptr = list->next;
            // 2 将 pre 的 prev 的 next 指向 新结点
            ptr->prev->next = new_node;
            // 3 new_node 的 next 指向 ptr
            new_node->next = ptr;
            // 4 new_node 的 prev 指向 ptr 的 prev
            new_node->prev = ptr->prev;
            // 5 ptr 的 prev 指向 new_node
            ptr->prev = new_node;
            // 6 头结点 指向 新结点
            list->next = new_node;
            return;
        }
        // 内部无数据的头插    内部无数据 默认 头插
        if (NULL == list->next)
        {
            list->next = new_node;
            return;
        }
    }

    // 中间插入

    u_node *ptr = list->next;

    for (size_t i = 1; i < pos - 1; i++)
    {
        ptr = ptr->next;
    }

    // 开始插入
    // 1、 新结点的 next 指向 ptr的next
    new_node->next = ptr->next;
    // 2、 ptr next prev 指向 新结点
    ptr->next->prev = new_node;
    // 3、 新结点 prev 指向 ptr
    new_node->prev = ptr;
    // 4、 ptr next 指向 new_node
    ptr->next = new_node;
}

// 双向链表的删除
void delete_double_node_u(u_list *list, int pos)
{

    // 安全判断
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 为 NULL");
        return;
    }

    // 删除
    u_node *ptr_1 = list->next;
    u_node *ptr_2 = ptr_1->next;

    // 头删  情况 1、 pos == 1  2、只有一个元素  ptr_1->next == list->nexts
    if (1 == pos || ptr_1->next == list->next)
    {
        // 只有一个结点数据的时候
        if (ptr_1->next == list->next)
        {
            free(list->next);
            list->next = NULL;
            return;
        }
        // 多个结点数据删第一个
        if (1 == pos)
        {
            // 1、 将头结点 指向 第二个 结点
            list->next = ptr_2;
            // 2、 将 ptr2 指向 尾结点
            ptr_2->prev = ptr_1->prev;
            // 3、 将尾结点 的 指向 第二个结点
            ptr_1->prev->next = ptr_2;
            // 4、 释放 ptr 1
            free(ptr_1);
        }
    }
}

// 双向链表的查找

// u_node *find_double_node_pos_u(u_list *list, int id)
// {
//     if (NULL == list)
//     {
//         ERRLOG("双向循环链表 为 NULL");
//         return NULL;
//     }
//     if (NULL == list->next)
//     {
//         ERRLOG("双向循环链表 无 数据");
//         return NULL;
//     }
//     u_node *ptr = list->next;
//     do
//     {
//         if (ptr->data.id == id)
//         {
//             return ptr;
//         }
//         ptr = ptr->next;
//     }while (ptr != list->next)
//     return NULL;
// }

u_node *find_double_node_name_u(u_list *list, char *name)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 无 数据");
        return NULL;
    }

    u_node *ptr = list->next;
    do
    {
        if (strcmp(ptr->data.name, name) == 0)
        {
            return ptr;
        }
        ptr = ptr->next;
    } while (ptr != list->next);
    return NULL;
}

// 双向链表的遍历
void print_forward_double_link_list_u(u_list *list)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 无 数据");
        return;
    }

    u_node *ptr = list->next;
    do
    {

        printf("用户名:%s\t密码:%s\t身份码:%d\t余额:%d\n",
               ptr->data.name, ptr->data.passwd, ptr->data.grade, ptr->data.value);
        ptr = ptr->next;

    } while (list->next != ptr);
    return;
}

void print_backwards_double_link_list_u(u_list *list);
// 双向链表的判空
int is_empty_double_link_list_u(u_list *list);

// 双向链表的清空
void clear_double_link_list_u(u_list *list)
{
    if (list == NULL)
    {
        ERRLOG("双向循环链表 为 NULL\n");
        return;
    }
    if (list->next == NULL)
    {
        return;
    }

    u_node *ptr_1 = list->next->prev;
    u_node *ptr_2 = list->next->prev->prev;

    while (list->next != ptr_1)
    {
        free(ptr_1);
        ptr_1 = ptr_2;
        if (list->next != ptr_2)
        {
            ptr_2 = ptr_2->prev;
        }
    }
    free(ptr_1);
}

// 双向链表的合并
u_list *merge_double_link_lists_u(u_list *list1, u_list *list2)
{
    // 安全判断
    if (list1 == NULL || list2 == NULL)
    {
        printf("链表不存在\n");
        return list1;
    }
    // 1、求链表list1 的链表长度
    int i;
    i = get_circulate_node_count_u(list1);

    // L2插入到L1中
    //  u_node* node1 = list1->next;
    u_node *node2 = list2->next;
    do
    {
        i++;
        insert_double_node_u(list1, node2->data, i);
        node2 = node2->next;
    } while (node2 != list2->next);
    return list1;
}

// 双向链表的销毁
void free_double_link_list_u(u_list **list)
{
    if (NULL == *list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }
    // 无数据的清空
    if (NULL == (*list)->next)
    {
        ERRLOG("链表内无数据");
        free(*list);
        *list = NULL;
        return;
    }

    // 有数据的清空
    u_node *ptr_1 = (*list)->next;
    u_node *ptr_2 = ptr_1->next;

    for (size_t i = 0; NULL != ptr_1; i++)
    {
        free(ptr_1);
        ptr_1 = ptr_2;
        if (NULL != ptr_2)
        {
            ptr_2 = ptr_2->next;
        }
    }

    free(*list);
    *list = NULL;

    return;
}
